MacTech 1 to 12/MacTech-vol-1-12.toast/Source/MacTech® Magazine/Volume 06 - 1990/06.08 Aug 90/LSObjectShell/MyMenus.p

Text File | 1989-09-26 | 13.3 KB | 581 lines | [TEXT/PJMM]

UNIT MyMenus;
{***********************************}
INTERFACE

    USES
        MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf, MacPrint, ObjIntf, GlobalStuff, StdWindows, StdMenus, MyDocuments;

    TYPE
        TSubMenu = OBJECT(TMenu)
                PROCEDURE Create (vRsrcID: Integer);
                override;
            END;

        TNewMenu = OBJECT(TSubMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TNewPictMenu = OBJECT(TNewMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TNewTextMenu = OBJECT(TNewMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TGraphMenu = OBJECT(TMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TColorMenu = OBJECT(TMenu)
            END;

        TForeCMenu = OBJECT(TSubMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TBackCMenu = OBJECT(TSubMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TTextMenu = OBJECT(TMenu)
            END;

        TFontMenu = OBJECT(TSubMenu)
                PROCEDURE Create (vRsrcID: Integer);
                override;
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TSizeMenu = OBJECT(TSubMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TStyleMenu = OBJECT(TSubMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

        TJustMenu = OBJECT(TSubMenu)
                PROCEDURE Choose (vItem: Integer);
                override;
            END;

    VAR
        oNewMenu: TNewMenu;
        oNewPictMenu: TNewPictMenu;
        oNewTextMenu: TNewTextMenu;
        oGraphMenu: TGraphMenu;
        oColorMenu: TColorMenu;
        oForeCMenu: TForeCMenu;
        oBackCMenu: TBackCMenu;
        oTextMenu: TTextMenu;
        oFontMenu: TFontMenu;
        oSizeMenu: TSizeMenu;
        oStyleMenu: TStyleMenu;
        oJustMenu: TJustMenu;

    PROCEDURE InitMyMenus;
    PROCEDURE ClickInMyMenus (vMenu, vItem: Integer);
    PROCEDURE SetMyMenuItems;
    PROCEDURE SetMyMenuBar;
    PROCEDURE DisposeMyMenus;

{***********************************}
IMPLEMENTATION

    PROCEDURE SetCheckMark (vMenuHdl: MenuHandle;
                                    vItem: Integer);
        VAR
            vMaxMItem: Integer;
            i: Integer;

    BEGIN
        vMaxMItem := CountMItems(vMenuHdl);
        FOR i := 1 TO vMaxMItem DO
            CheckItem(vMenuHdl, i, (i = vItem));
    END;    {SetCheckMark}

{----------------------------------------}
    PROCEDURE OutlineFontSize (vFontNumber: Integer);
        VAR
            vSizeMenu: MenuHandle;
            vSizeName: Str255;
            vSizeNumber: LongInt;
            i: Integer;

    BEGIN
        vSizeMenu := oSizeMenu.fMenuHdl;
        FOR i := 1 TO CountMItems(vSizeMenu) DO
            BEGIN
                GetItem(vSizeMenu, i, vSizeName);
                StringToNum(vSizeName, vSizeNumber);
                IF RealFont(vFontNumber, vSizeNumber) THEN
                    SetItemStyle(vSizeMenu, i, [Outline])
                ELSE
                    SetItemStyle(vSizeMenu, i, []);
            END;
    END;    {OutlineFontSize}

{----------------------------------------}
    PROCEDURE CheckFontMenu (vMenuHdl: MenuHandle);
        VAR
            vMaxMItem: Integer;
            vFontName: Str255;
            vFontNumber: Integer;
            vCurrentFont: Str255;
            i: Integer;

    BEGIN
        vMaxMItem := CountMItems(vMenuHdl);
        GetFontName(thePort^.txFont, vCurrentFont);
        FOR i := 1 TO vMaxMItem DO
            BEGIN
                GetItem(vMenuHdl, i, vFontName);
                IF vFontName = vCurrentFont THEN
                    BEGIN
                        SetCheckMark(vMenuHdl, i);
                        GetFNum(vFontName, vFontNumber);
                        OutlineFontSize(vFontNumber);
                        leave;
                    END;
            END;
    END;    {CheckFontMenu}

{----------------------------------------}
    PROCEDURE CheckSizeMenu (vMenuHdl: MenuHandle);
        VAR
            vMaxMItem: Integer;
            vSizeName: Str255;
            vSizeNumber: LongInt;
            vCurrentSize: Integer;
            i: Integer;

    BEGIN
        vMaxMItem := CountMItems(vMenuHdl);
        vCurrentSize := thePort^.txSize;
        FOR i := 1 TO vMaxMItem DO
            BEGIN
                GetItem(vMenuHdl, i, vSizeName);
                StringToNum(vSizeName, vSizeNumber);
                IF LoWord(vSizeNumber) = vCurrentSize THEN
                    BEGIN
                        SetCheckMark(vMenuHdl, i);
                        leave;
                    END;
            END;
    END;    {CheckSizeMenu}

{----------------------------------------}
    PROCEDURE CheckStyleMenu (vMenuHdl: MenuHandle);
        VAR
            i: Integer;
            vStylePtr: Ptr;

    BEGIN
        vStylePtr := oWindow.oDocument.fMyHdl^;
        FOR i := kPlain TO kExtend DO
            CheckItem(vMenuHdl, i, BitTst(vStylePtr, i - 1))
    END;    {CheckStyleMenu}

{----------------------------------------}
    PROCEDURE CheckJustMenu (vMenuHdl: MenuHandle);
        VAR
            vJust: Integer;
            vItem: Integer;

    BEGIN
        vJust := oWindow.oDocument.fTextHdl^^.just;
        CASE vJust OF
            teJustLeft:
                vItem := kLeft;
            teJustCenter:
                vItem := kCenter;
            OTHERWISE
                vItem := kRight;
        END;
        SetCheckMark(vMenuHdl, vItem);
    END;    {CheckJustMenu}

{----------------------------------------}
    PROCEDURE SwitchMenus (vPictFlag, vTextFlag: BOOLEAN);

        PROCEDURE DoInsertMenu (vMenuHdl: MenuHandle;
                                        vRsrcID: Integer;
                                        vFlag: BOOLEAN);
        BEGIN
            IF vFlag THEN
                InsertMenu(vMenuHdl, 0)
            ELSE
                DeleteMenu(vRsrcID);
        END;    {DoInsertMenu}

{-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -}
    BEGIN
        IF vPictFlag = FALSE THEN
            BEGIN
                DoInsertMenu(oGraphMenu.fMenuHdl, kGraphID, vPictFlag);
                DoInsertMenu(oColorMenu.fMenuHdl, kColorID, vPictFlag);
                DoInsertMenu(oTextMenu.fMenuHdl, kTextID, vTextFlag);
                DoInsertMenu(oColorMenu.fMenuHdl, kColorID, vTextFlag);

                IF vTextFlag = TRUE THEN
                    BEGIN
                        CheckFontMenu(oFontMenu.fMenuHdl);
                        CheckSizeMenu(oSizeMenu.fMenuHdl);
                        CheckStyleMenu(oStyleMenu.fMenuHdl);
                        CheckJustMenu(oJustMenu.fMenuHdl);
                        WITH oWindow.oDocument DO
                            BEGIN
                                SetCheckMark(oForeCMenu.fMenuHdl, fForeC);
                                SetCheckMark(oBackCMenu.fMenuHdl, fBackC);
                            END;
                    END;
            END
        ELSE
            BEGIN
                DoInsertMenu(oTextMenu.fMenuHdl, kTextID, vTextFlag);
                DoInsertMenu(oColorMenu.fMenuHdl, kColorID, vTextFlag);
                DoInsertMenu(oGraphMenu.fMenuHdl, kGraphID, vPictFlag);
                DoInsertMenu(oColorMenu.fMenuHdl, kColorID, vPictFlag);
                WITH oWindow.oDocument DO
                    BEGIN
                        SetCheckMark(oGraphMenu.fMenuHdl, fShapeID);
                        SetCheckMark(oForeCMenu.fMenuHdl, fForeC);
                        SetCheckMark(oBackCMenu.fMenuHdl, fBackC);
                    END;
            END;
    END;    {SwitchMenus}

{========================================}
    PROCEDURE InitMyMenus;
    BEGIN
        New(oNewMenu);
        oNewMenu.Create(kNewID);

        New(oNewPictMenu);
        oNewPictMenu.Create(kNewPictID);

        New(oNewTextMenu);
        oNewTextMenu.Create(kNewTextID);

        New(oGraphMenu);
        oGraphMenu.Create(kGraphID);

        New(oColorMenu);
        oColorMenu.Create(kColorID);

        New(oForeCMenu);
        oForeCMenu.Create(kForeCID);

        New(oBackCMenu);
        oBackCMenu.Create(kBackCID);

        New(oTextMenu);
        oTextMenu.Create(kTextID);

        New(oFontMenu);
        oFontMenu.Create(kFontID);

        New(oSizeMenu);
        oSizeMenu.Create(kSizeID);

        New(oStyleMenu);
        oStyleMenu.Create(kStyleID);

        New(oJustMenu);
        oJustMenu.Create(kJustID);

        SwitchMenus(FALSE, FALSE);
    END;    {InitMyMenus}

{========================================}
    PROCEDURE ClickInMyMenus (vMenu, vItem: Integer);
    BEGIN
        CASE vMenu OF
            kNewPictID:
                oNewPictMenu.Choose(vItem);
            kNewTextID:
                oNewTextMenu.Choose(vItem);
            kGraphID:
                oGraphMenu.Choose(vItem);
            kForeCID:
                oForeCMenu.Choose(vItem);
            kBackCID:
                oBackCMenu.Choose(vItem);
            kFontID:
                oFontMenu.Choose(vItem);
            kSizeID:
                oSizeMenu.Choose(vItem);
            kStyleID:
                oStyleMenu.Choose(vItem);
            kJustID:
                oJustMenu.Choose(vItem);
            OTHERWISE
        END;
    END;    {ClickInMyMenus}

{========================================}
    PROCEDURE SetMyMenuItems;
        VAR
            vFrontWFlag: BOOLEAN;
            vUserWFlag: BOOLEAN;

    BEGIN
        vFrontWFlag := (FrontWindow <> NIL);
        vUserWFlag := IsAppWindow(FrontWindow);
{Enable/disable items of MyMenus}
    END;    {SetMyMenuItems}

{========================================}
    PROCEDURE SetMyMenuBar;
        VAR
            vFrontWFlag: BOOLEAN;
            vUserWFlag: BOOLEAN;
            vDocType: OSType;

    BEGIN
        vFrontWFlag := (FrontWindow <> NIL);
        vUserWFlag := IsAppWindow(FrontWindow);
        IF NOT vFrontWFlag THEN
            SwitchMenus(FALSE, FALSE);
        IF vUserWFlag THEN
            BEGIN
                oWindow := TWindow(GetWRefCon(FrontWindow));
                vDocType := oWindow.oDocument.fDocType;
                IF vDocType = kPictDoc THEN
                    SwitchMenus(TRUE, FALSE)
                ELSE IF vDocType = kTextDoc THEN
                    SwitchMenus(FALSE, TRUE);
            END
        ELSE
{SwitchMenus(FALSE, FALSE)}
            ;
        SetEnable(kEditID, 0, vFrontWFlag);
        SetEnable(kGraphID, 0, vUserWFlag);
        SetEnable(kTextID, 0, vUserWFlag);
        SetEnable(kColorID, 0, vUserWFlag);
        DrawMenuBar;
    END;    {SetMyMenuBar}

{========================================}
    PROCEDURE DisposeMyMenus;
    BEGIN
        oNewMenu.Free;
        oNewPictMenu.Free;
        oNewTextMenu.Free;
        oGraphMenu.Free;
        oColorMenu.Free;
        oForeCMenu.Free;
        oBackCMenu.Free;
        oTextMenu.Free;
        oFontMenu.Free;
        oSizeMenu.Free;
        oStyleMenu.Free;
        oJustMenu.Free;
    END;    {DisposeMyMenus}

{========================================}
    PROCEDURE TSubMenu.Create (vRsrcID: Integer);
    BEGIN
        HLock(Handle(Self));
        fMenuHdl := GetMenu(vRsrcID);
        InsertMenu(fMenuHdl, -1);
        HUnlock(Handle(Self));
    END; {Create}

{========================================}
    PROCEDURE TNewMenu.Choose (vItem: Integer);
    BEGIN
        CASE vItem OF
            kNoGrow:
                New(TWindow(oWindow));
            kGrow:
                New(TGrowWindow(oWindow));
            kHScroll..kScroll:
                New(TScrollWindow(oWindow));
            kHScrollZoom..kScrollZoom:
                IF BitTst(Ptr(ROM85), 0) THEN
                    New(TScrollWindow(oWindow))
                ELSE
                    New(TScrollZoomWindow(oWindow));
            OTHERWISE
        END;
        oWindow.fWKind := vItem;
    END; {Choose}

{----------------------------------------}
    PROCEDURE TNewPictMenu.Choose (vItem: Integer);
    BEGIN
        INHERITED Choose(vItem);
        oWindow.DoNew(kPictDoc);
        ShowWindow(oWindow.fWPtr);
        SetCheckMark(oForeCMenu.fMenuHdl, kBlack);
        SetCheckMark(oBackCMenu.fMenuHdl, kWhite);
    END; {Choose}

{----------------------------------------}
    PROCEDURE TNewTextMenu.Choose (vItem: Integer);
    BEGIN
        INHERITED Choose(vItem);
        oWindow.DoNew(kTextDoc);
        ShowWindow(oWindow.fWPtr);
        CheckFontMenu(oFontMenu.fMenuHdl);
        CheckSizeMenu(oSizeMenu.fMenuHdl);
        CheckStyleMenu(oStyleMenu.fMenuHdl);
        SetCheckMark(oJustMenu.fMenuHdl, kLeft);
        SetCheckMark(oForeCMenu.fMenuHdl, kBlack);
        SetCheckMark(oBackCMenu.fMenuHdl, kWhite);
    END; {Choose}

{========================================}
    PROCEDURE TGraphMenu.Choose (vItem: Integer);
    BEGIN
        oWindow := TWindow(GetWRefCon(FrontWindow));
        oWindow.oDocument.fShapeID := vItem;
        SetCheckMark(fMenuHdl, vItem);
    END; {Choose}

{========================================}
    PROCEDURE TForeCMenu.Choose (vItem: Integer);
    BEGIN
        oWindow := TWindow(GetWRefCon(FrontWindow));
        oWindow.oDocument.fForeC := vItem;
        oWindow.ReDrawContent;
        SetCheckMark(fMenuHdl, vItem);
    END; {Choose}

{----------------------------------------}
    PROCEDURE TBackCMenu.Choose (vItem: Integer);
    BEGIN
        oWindow := TWindow(GetWRefCon(FrontWindow));
        oWindow.oDocument.fBackC := vItem;
        oWindow.ReDrawContent;
        SetCheckMark(fMenuHdl, vItem);
    END; {Choose}

{========================================}
    PROCEDURE TFontMenu.Create (vRsrcID: Integer);
    BEGIN
        HLock(Handle(Self));
        fMenuHdl := GetMenu(vRsrcID);
        AddResMenu(fMenuHdl, 'FONT');
        InsertMenu(fMenuHdl, -1);
        HUnlock(Handle(Self));
    END; {Create}

{----------------------------------------}
    PROCEDURE TFontMenu.Choose (vItem: Integer);
        VAR
            vFontName: Str255;
            vFontNumber: Integer;

    BEGIN
        GetItem(fMenuHdl, vItem, vFontName);
        GetFNum(vFontName, vFontNumber);
        TextFont(vFontNumber);
        oWindow := TWindow(GetWRefCon(FrontWindow));
        oWindow.oDocument.fTextHdl^^.txFont := vFontNumber;
        oWindow.ReDrawContent;
        SetCheckMark(fMenuHdl, vItem);
        OutlineFontSize(vFontNumber);
    END; {Choose}

{========================================}
    PROCEDURE TSizeMenu.Choose (vItem: Integer);
        VAR
            vSizeName: Str255;
            vSizeNumber: LongInt;

    BEGIN
        GetItem(fMenuHdl, vItem, vSizeName);
        StringToNum(vSizeName, vSizeNumber);
        TextSize(LoWord(vSizeNumber));
        oWindow := TWindow(GetWRefCon(FrontWindow));
        oWindow.oDocument.fTextHdl^^.txSize := LoWord(vSizeNumber);
        oWindow.ReDrawContent;
        SetCheckMark(fMenuHdl, vItem);
    END; {Choose}

{========================================}
    PROCEDURE TStyleMenu.Choose (vItem: Integer);
        VAR
            vStyle: Style;
            vStylePtr: Ptr;
    BEGIN
        oWindow := TWindow(GetWRefCon(FrontWindow));
        WITH oWindow.oDocument DO
            BEGIN
                vStylePtr := fMyHdl^;
                vStyle := [];
                CASE vItem OF
                    kPlain:
                        BEGIN
                            TextFace([]);
                            fMyHdl^^ := -128;
                        END;
                    kBold:
                        vStyle := [Bold];
                    kItalic:
                        vStyle := [Italic];
                    kUnderline:
                        vStyle := [Underline];
                    kOutline:
                        vStyle := [Outline];
                    kShadow:
                        vStyle := [Shadow];
                    kCondense:
                        vStyle := [Condense];
                    kExtend:
                        vStyle := [Extend];
                    OTHERWISE
                END;
                IF (vStyle <= thePort^.txFace) AND (vItem <> kPlain) THEN
                    BEGIN
                        TextFace(thePort^.txFace - vStyle);
                        BitClr(vStylePtr, vItem - 1);
                    END
                ELSE
                    BEGIN
                        TextFace(thePort^.txFace + vStyle);
                        BitClr(vStylePtr, kPlain - 1);
                        BitSet(vStylePtr, vItem - 1);
                    END;
                fTextHdl^^.txFace := thePort^.txFace;
                fMyHdl^^ := vStylePtr^;
            END;
        oWindow.ReDrawContent;
        CheckStyleMenu(fMenuHdl);
    END; {Choose}

{========================================}
    PROCEDURE TJustMenu.Choose (vItem: Integer);
        VAR
            vJust: Integer;

    BEGIN
        oWindow := TWindow(GetWRefCon(FrontWindow));
        CASE vItem OF
            kLeft:
                vJust := teJustLeft;
            kCenter:
                vJust := teJustCenter;
            kRight:
                vJust := teJustRight;
            OTHERWISE
        END;
        oWindow.oDocument.fTextHdl^^.just := vJust;
        oWindow.ReDrawContent;
        SetCheckMark(fMenuHdl, vItem);
    END; {Choose}

END. {unit MyMenus}
{***********************************}